(function webpackUniversalModuleDefinition(root, factory) {
  if (typeof exports === "object" && typeof module === "object")
    module.exports = factory(require("katex"));
  else if (typeof define === "function" && define.amd)
    define(["katex"], factory);
  else {
    var a =
      typeof exports === "object"
        ? factory(require("katex"))
        : factory(root["katex"]);
    for (var i in a) (typeof exports === "object" ? exports : root)[i] = a[i];
  }
})(
  typeof self !== "undefined" ? self : this,
  function (__WEBPACK_EXTERNAL_MODULE__974__) {
    return /******/ (function () {
      // webpackBootstrap
      /******/ "use strict";
      /******/ var __webpack_modules__ = {
        /***/ 974: /***/ function (module) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__974__;

          /***/
        },

        /******/
      }; // The module cache
      /************************************************************************/
      /******/ /******/ var __webpack_module_cache__ = {}; // The require function
      /******/
      /******/ /******/ function __webpack_require__(moduleId) {
        /******/ // Check if module is in cache
        /******/ var cachedModule = __webpack_module_cache__[moduleId];
        /******/ if (cachedModule !== undefined) {
          /******/ return cachedModule.exports;
          /******/
        } // Create a new module (and put it into the cache)
        /******/ /******/ var module = (__webpack_module_cache__[moduleId] = {
          /******/ // no module.id needed
          /******/ // no module.loaded needed
          /******/ exports: {},
          /******/
        }); // Execute the module function
        /******/
        /******/ /******/ __webpack_modules__[moduleId](
          module,
          module.exports,
          __webpack_require__
        ); // Return the exports of the module
        /******/
        /******/ /******/ return module.exports;
        /******/
      } /* webpack/runtime/compat get default export */
      /******/
      /************************************************************************/
      /******/ /******/ !(function () {
        /******/ // getDefaultExport function for compatibility with non-harmony modules
        /******/ __webpack_require__.n = function (module) {
          /******/ var getter =
            module && module.__esModule
              ? /******/ function () {
                  return module["default"];
                }
              : /******/ function () {
                  return module;
                };
          /******/ __webpack_require__.d(getter, { a: getter });
          /******/ return getter;
          /******/
        };
        /******/
      })(); /* webpack/runtime/define property getters */
      /******/
      /******/ /******/ !(function () {
        /******/ // define getter functions for harmony exports
        /******/ __webpack_require__.d = function (exports, definition) {
          /******/ for (var key in definition) {
            /******/ if (
              __webpack_require__.o(definition, key) &&
              !__webpack_require__.o(exports, key)
            ) {
              /******/ Object.defineProperty(exports, key, {
                enumerable: true,
                get: definition[key],
              });
              /******/
            }
            /******/
          }
          /******/
        };
        /******/
      })(); /* webpack/runtime/hasOwnProperty shorthand */
      /******/
      /******/ /******/ !(function () {
        /******/ __webpack_require__.o = function (obj, prop) {
          return Object.prototype.hasOwnProperty.call(obj, prop);
        };
        /******/
      })();
      /******/
      /************************************************************************/
      var __webpack_exports__ = {};
      // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
      !(function () {
        /* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
          974
        );
        /* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/ __webpack_require__.n(
          katex__WEBPACK_IMPORTED_MODULE_0__
        );
        /**
         * renderA11yString returns a readable string.
         *
         * In some cases the string will have the proper semantic math
         * meaning,:
         *   renderA11yString("\\frac{1}{2}"")
         *   -> "start fraction, 1, divided by, 2, end fraction"
         *
         * However, other cases do not:
         *   renderA11yString("f(x) = x^2")
         *   -> "f, left parenthesis, x, right parenthesis, equals, x, squared"
         *
         * The commas in the string aim to increase ease of understanding
         * when read by a screenreader.
         */
        // NOTE: since we're importing types here these files won't actually be
        // included in the build.
        // $FlowIgnore: we import the types directly anyways

        var stringMap = {
          "(": "left parenthesis",
          ")": "right parenthesis",
          "[": "open bracket",
          "]": "close bracket",
          "\\{": "left brace",
          "\\}": "right brace",
          "\\lvert": "open vertical bar",
          "\\rvert": "close vertical bar",
          "|": "vertical bar",
          "\\uparrow": "up arrow",
          "\\Uparrow": "up arrow",
          "\\downarrow": "down arrow",
          "\\Downarrow": "down arrow",
          "\\updownarrow": "up down arrow",
          "\\leftarrow": "left arrow",
          "\\Leftarrow": "left arrow",
          "\\rightarrow": "right arrow",
          "\\Rightarrow": "right arrow",
          "\\langle": "open angle",
          "\\rangle": "close angle",
          "\\lfloor": "open floor",
          "\\rfloor": "close floor",
          "\\int": "integral",
          "\\intop": "integral",
          "\\lim": "limit",
          "\\ln": "natural log",
          "\\log": "log",
          "\\sin": "sine",
          "\\cos": "cosine",
          "\\tan": "tangent",
          "\\cot": "cotangent",
          "\\sum": "sum",
          "/": "slash",
          ",": "comma",
          ".": "point",
          "-": "negative",
          "+": "plus",
          "~": "tilde",
          ":": "colon",
          "?": "question mark",
          "'": "apostrophe",
          "\\%": "percent",
          " ": "space",
          "\\ ": "space",
          "\\$": "dollar sign",
          "\\angle": "angle",
          "\\degree": "degree",
          "\\circ": "circle",
          "\\vec": "vector",
          "\\triangle": "triangle",
          "\\pi": "pi",
          "\\prime": "prime",
          "\\infty": "infinity",
          "\\alpha": "alpha",
          "\\beta": "beta",
          "\\gamma": "gamma",
          "\\omega": "omega",
          "\\theta": "theta",
          "\\sigma": "sigma",
          "\\lambda": "lambda",
          "\\tau": "tau",
          "\\Delta": "delta",
          "\\delta": "delta",
          "\\mu": "mu",
          "\\rho": "rho",
          "\\nabla": "del",
          "\\ell": "ell",
          "\\ldots": "dots",
          // TODO: add entries for all accents
          "\\hat": "hat",
          "\\acute": "acute",
        };
        var powerMap = {
          prime: "prime",
          degree: "degrees",
          circle: "degrees",
          2: "squared",
          3: "cubed",
        };
        var openMap = {
          "|": "open vertical bar",
          ".": "",
        };
        var closeMap = {
          "|": "close vertical bar",
          ".": "",
        };
        var binMap = {
          "+": "plus",
          "-": "minus",
          "\\pm": "plus minus",
          "\\cdot": "dot",
          "*": "times",
          "/": "divided by",
          "\\times": "times",
          "\\div": "divided by",
          "\\circ": "circle",
          "\\bullet": "bullet",
        };
        var relMap = {
          "=": "equals",
          "\\approx": "approximately equals",
          "≠": "does not equal",
          "\\geq": "is greater than or equal to",
          "\\ge": "is greater than or equal to",
          "\\leq": "is less than or equal to",
          "\\le": "is less than or equal to",
          ">": "is greater than",
          "<": "is less than",
          "\\leftarrow": "left arrow",
          "\\Leftarrow": "left arrow",
          "\\rightarrow": "right arrow",
          "\\Rightarrow": "right arrow",
          ":": "colon",
        };
        var accentUnderMap = {
          "\\underleftarrow": "left arrow",
          "\\underrightarrow": "right arrow",
          "\\underleftrightarrow": "left-right arrow",
          "\\undergroup": "group",
          "\\underlinesegment": "line segment",
          "\\utilde": "tilde",
        };

        var buildString = function buildString(str, type, a11yStrings) {
          if (!str) {
            return;
          }

          var ret;

          if (type === "open") {
            ret = str in openMap ? openMap[str] : stringMap[str] || str;
          } else if (type === "close") {
            ret = str in closeMap ? closeMap[str] : stringMap[str] || str;
          } else if (type === "bin") {
            ret = binMap[str] || str;
          } else if (type === "rel") {
            ret = relMap[str] || str;
          } else {
            ret = stringMap[str] || str;
          } // If the text to add is a number and there is already a string
          // in the list and the last string is a number then we should
          // combine them into a single number

          if (
            /^\d+$/.test(ret) &&
            a11yStrings.length > 0 && // TODO(kevinb): check that the last item in a11yStrings is a string
            // I think we might be able to drop the nested arrays, which would make
            // this easier to type
            // $FlowFixMe
            /^\d+$/.test(a11yStrings[a11yStrings.length - 1])
          ) {
            a11yStrings[a11yStrings.length - 1] += ret;
          } else if (ret) {
            a11yStrings.push(ret);
          }
        };

        var buildRegion = function buildRegion(a11yStrings, callback) {
          var regionStrings = [];
          a11yStrings.push(regionStrings);
          callback(regionStrings);
        };

        var handleObject = function handleObject(tree, a11yStrings, atomType) {
          // Everything else is assumed to be an object...
          switch (tree.type) {
            case "accent": {
              buildRegion(a11yStrings, function (a11yStrings) {
                buildA11yStrings(tree.base, a11yStrings, atomType);
                a11yStrings.push("with");
                buildString(tree.label, "normal", a11yStrings);
                a11yStrings.push("on top");
              });
              break;
            }

            case "accentUnder": {
              buildRegion(a11yStrings, function (a11yStrings) {
                buildA11yStrings(tree.base, a11yStrings, atomType);
                a11yStrings.push("with");
                buildString(accentUnderMap[tree.label], "normal", a11yStrings);
                a11yStrings.push("underneath");
              });
              break;
            }

            case "accent-token": {
              // Used internally by accent symbols.
              break;
            }

            case "atom": {
              var text = tree.text;

              switch (tree.family) {
                case "bin": {
                  buildString(text, "bin", a11yStrings);
                  break;
                }

                case "close": {
                  buildString(text, "close", a11yStrings);
                  break;
                }
                // TODO(kevinb): figure out what should be done for inner

                case "inner": {
                  buildString(tree.text, "inner", a11yStrings);
                  break;
                }

                case "open": {
                  buildString(text, "open", a11yStrings);
                  break;
                }

                case "punct": {
                  buildString(text, "punct", a11yStrings);
                  break;
                }

                case "rel": {
                  buildString(text, "rel", a11yStrings);
                  break;
                }

                default: {
                  tree.family;
                  throw new Error(
                    '"' + tree.family + '" is not a valid atom type'
                  );
                }
              }

              break;
            }

            case "color": {
              var color = tree.color.replace(/katex-/, "");
              buildRegion(a11yStrings, function (regionStrings) {
                regionStrings.push("start color " + color);
                buildA11yStrings(tree.body, regionStrings, atomType);
                regionStrings.push("end color " + color);
              });
              break;
            }

            case "color-token": {
              // Used by \color, \colorbox, and \fcolorbox but not directly rendered.
              // It's a leaf node and has no children so just break.
              break;
            }

            case "delimsizing": {
              if (tree.delim && tree.delim !== ".") {
                buildString(tree.delim, "normal", a11yStrings);
              }

              break;
            }

            case "genfrac": {
              buildRegion(a11yStrings, function (regionStrings) {
                // genfrac can have unbalanced delimiters
                var leftDelim = tree.leftDelim,
                  rightDelim = tree.rightDelim; // NOTE: Not sure if this is a safe assumption
                // hasBarLine true -> fraction, false -> binomial

                if (tree.hasBarLine) {
                  regionStrings.push("start fraction");
                  leftDelim && buildString(leftDelim, "open", regionStrings);
                  buildA11yStrings(tree.numer, regionStrings, atomType);
                  regionStrings.push("divided by");
                  buildA11yStrings(tree.denom, regionStrings, atomType);
                  rightDelim && buildString(rightDelim, "close", regionStrings);
                  regionStrings.push("end fraction");
                } else {
                  regionStrings.push("start binomial");
                  leftDelim && buildString(leftDelim, "open", regionStrings);
                  buildA11yStrings(tree.numer, regionStrings, atomType);
                  regionStrings.push("over");
                  buildA11yStrings(tree.denom, regionStrings, atomType);
                  rightDelim && buildString(rightDelim, "close", regionStrings);
                  regionStrings.push("end binomial");
                }
              });
              break;
            }

            case "hbox": {
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "kern": {
              // No op: we don't attempt to present kerning information
              // to the screen reader.
              break;
            }

            case "leftright": {
              buildRegion(a11yStrings, function (regionStrings) {
                buildString(tree.left, "open", regionStrings);
                buildA11yStrings(tree.body, regionStrings, atomType);
                buildString(tree.right, "close", regionStrings);
              });
              break;
            }

            case "leftright-right": {
              // TODO: double check that this is a no-op
              break;
            }

            case "lap": {
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "mathord": {
              buildString(tree.text, "normal", a11yStrings);
              break;
            }

            case "op": {
              var body = tree.body,
                name = tree.name;

              if (body) {
                buildA11yStrings(body, a11yStrings, atomType);
              } else if (name) {
                buildString(name, "normal", a11yStrings);
              }

              break;
            }

            case "op-token": {
              // Used internally by operator symbols.
              buildString(tree.text, atomType, a11yStrings);
              break;
            }

            case "ordgroup": {
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "overline": {
              buildRegion(a11yStrings, function (a11yStrings) {
                a11yStrings.push("start overline");
                buildA11yStrings(tree.body, a11yStrings, atomType);
                a11yStrings.push("end overline");
              });
              break;
            }

            case "phantom": {
              a11yStrings.push("empty space");
              break;
            }

            case "raisebox": {
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "rule": {
              a11yStrings.push("rectangle");
              break;
            }

            case "sizing": {
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "spacing": {
              a11yStrings.push("space");
              break;
            }

            case "styling": {
              // We ignore the styling and just pass through the contents
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "sqrt": {
              buildRegion(a11yStrings, function (regionStrings) {
                var body = tree.body,
                  index = tree.index;

                if (index) {
                  var indexString = flatten(
                    buildA11yStrings(index, [], atomType)
                  ).join(",");

                  if (indexString === "3") {
                    regionStrings.push("cube root of");
                    buildA11yStrings(body, regionStrings, atomType);
                    regionStrings.push("end cube root");
                    return;
                  }

                  regionStrings.push("root");
                  regionStrings.push("start index");
                  buildA11yStrings(index, regionStrings, atomType);
                  regionStrings.push("end index");
                  return;
                }

                regionStrings.push("square root of");
                buildA11yStrings(body, regionStrings, atomType);
                regionStrings.push("end square root");
              });
              break;
            }

            case "supsub": {
              var base = tree.base,
                sub = tree.sub,
                sup = tree.sup;
              var isLog = false;

              if (base) {
                buildA11yStrings(base, a11yStrings, atomType);
                isLog = base.type === "op" && base.name === "\\log";
              }

              if (sub) {
                var regionName = isLog ? "base" : "subscript";
                buildRegion(a11yStrings, function (regionStrings) {
                  regionStrings.push("start " + regionName);
                  buildA11yStrings(sub, regionStrings, atomType);
                  regionStrings.push("end " + regionName);
                });
              }

              if (sup) {
                buildRegion(a11yStrings, function (regionStrings) {
                  var supString = flatten(
                    buildA11yStrings(sup, [], atomType)
                  ).join(",");

                  if (supString in powerMap) {
                    regionStrings.push(powerMap[supString]);
                    return;
                  }

                  regionStrings.push("start superscript");
                  buildA11yStrings(sup, regionStrings, atomType);
                  regionStrings.push("end superscript");
                });
              }

              break;
            }

            case "text": {
              // TODO: handle other fonts
              if (tree.font === "\\textbf") {
                buildRegion(a11yStrings, function (regionStrings) {
                  regionStrings.push("start bold text");
                  buildA11yStrings(tree.body, regionStrings, atomType);
                  regionStrings.push("end bold text");
                });
                break;
              }

              buildRegion(a11yStrings, function (regionStrings) {
                regionStrings.push("start text");
                buildA11yStrings(tree.body, regionStrings, atomType);
                regionStrings.push("end text");
              });
              break;
            }

            case "textord": {
              buildString(tree.text, atomType, a11yStrings);
              break;
            }

            case "smash": {
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "enclose": {
              // TODO: create a map for these.
              // TODO: differentiate between a body with a single atom, e.g.
              // "cancel a" instead of "start cancel, a, end cancel"
              if (/cancel/.test(tree.label)) {
                buildRegion(a11yStrings, function (regionStrings) {
                  regionStrings.push("start cancel");
                  buildA11yStrings(tree.body, regionStrings, atomType);
                  regionStrings.push("end cancel");
                });
                break;
              } else if (/box/.test(tree.label)) {
                buildRegion(a11yStrings, function (regionStrings) {
                  regionStrings.push("start box");
                  buildA11yStrings(tree.body, regionStrings, atomType);
                  regionStrings.push("end box");
                });
                break;
              } else if (/sout/.test(tree.label)) {
                buildRegion(a11yStrings, function (regionStrings) {
                  regionStrings.push("start strikeout");
                  buildA11yStrings(tree.body, regionStrings, atomType);
                  regionStrings.push("end strikeout");
                });
                break;
              } else if (/phase/.test(tree.label)) {
                buildRegion(a11yStrings, function (regionStrings) {
                  regionStrings.push("start phase angle");
                  buildA11yStrings(tree.body, regionStrings, atomType);
                  regionStrings.push("end phase angle");
                });
                break;
              }

              throw new Error(
                "KaTeX-a11y: enclose node with " +
                  tree.label +
                  " not supported yet"
              );
            }

            case "vcenter": {
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "vphantom": {
              throw new Error("KaTeX-a11y: vphantom not implemented yet");
            }

            case "hphantom": {
              throw new Error("KaTeX-a11y: hphantom not implemented yet");
            }

            case "operatorname": {
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "array": {
              throw new Error("KaTeX-a11y: array not implemented yet");
            }

            case "raw": {
              throw new Error("KaTeX-a11y: raw not implemented yet");
            }

            case "size": {
              // Although there are nodes of type "size" in the parse tree, they have
              // no semantic meaning and should be ignored.
              break;
            }

            case "url": {
              throw new Error("KaTeX-a11y: url not implemented yet");
            }

            case "tag": {
              throw new Error("KaTeX-a11y: tag not implemented yet");
            }

            case "verb": {
              buildString("start verbatim", "normal", a11yStrings);
              buildString(tree.body, "normal", a11yStrings);
              buildString("end verbatim", "normal", a11yStrings);
              break;
            }

            case "environment": {
              throw new Error("KaTeX-a11y: environment not implemented yet");
            }

            case "horizBrace": {
              buildString(
                "start " + tree.label.slice(1),
                "normal",
                a11yStrings
              );
              buildA11yStrings(tree.base, a11yStrings, atomType);
              buildString("end " + tree.label.slice(1), "normal", a11yStrings);
              break;
            }

            case "infix": {
              // All infix nodes are replace with other nodes.
              break;
            }

            case "includegraphics": {
              throw new Error(
                "KaTeX-a11y: includegraphics not implemented yet"
              );
            }

            case "font": {
              // TODO: callout the start/end of specific fonts
              // TODO: map \BBb{N} to "the naturals" or something like that
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            case "href": {
              throw new Error("KaTeX-a11y: href not implemented yet");
            }

            case "cr": {
              // This is used by environments.
              throw new Error("KaTeX-a11y: cr not implemented yet");
            }

            case "underline": {
              buildRegion(a11yStrings, function (a11yStrings) {
                a11yStrings.push("start underline");
                buildA11yStrings(tree.body, a11yStrings, atomType);
                a11yStrings.push("end underline");
              });
              break;
            }

            case "xArrow": {
              throw new Error("KaTeX-a11y: xArrow not implemented yet");
            }

            case "cdlabel": {
              throw new Error("KaTeX-a11y: cdlabel not implemented yet");
            }

            case "cdlabelparent": {
              throw new Error("KaTeX-a11y: cdlabelparent not implemented yet");
            }

            case "mclass": {
              // \neq and \ne are macros so we let "htmlmathml" render the mathmal
              // side of things and extract the text from that.
              var _atomType = tree.mclass.slice(1); // $FlowFixMe: drop the leading "m" from the values in mclass

              buildA11yStrings(tree.body, a11yStrings, _atomType);
              break;
            }

            case "mathchoice": {
              // TODO: track which which style we're using, e.g. dispaly, text, etc.
              // default to text style if even that may not be the correct style
              buildA11yStrings(tree.text, a11yStrings, atomType);
              break;
            }

            case "htmlmathml": {
              buildA11yStrings(tree.mathml, a11yStrings, atomType);
              break;
            }

            case "middle": {
              buildString(tree.delim, atomType, a11yStrings);
              break;
            }

            case "internal": {
              // internal nodes are never included in the parse tree
              break;
            }

            case "html": {
              buildA11yStrings(tree.body, a11yStrings, atomType);
              break;
            }

            default:
              tree.type;
              throw new Error("KaTeX a11y un-recognized type: " + tree.type);
          }
        };

        var buildA11yStrings = function buildA11yStrings(
          tree,
          a11yStrings,
          atomType
        ) {
          if (a11yStrings === void 0) {
            a11yStrings = [];
          }

          if (tree instanceof Array) {
            for (var i = 0; i < tree.length; i++) {
              buildA11yStrings(tree[i], a11yStrings, atomType);
            }
          } else {
            handleObject(tree, a11yStrings, atomType);
          }

          return a11yStrings;
        };

        var flatten = function flatten(array) {
          var result = [];
          array.forEach(function (item) {
            if (item instanceof Array) {
              result = result.concat(flatten(item));
            } else {
              result.push(item);
            }
          });
          return result;
        };

        var renderA11yString = function renderA11yString(text, settings) {
          var tree = katex__WEBPACK_IMPORTED_MODULE_0___default().__parse(
            text,
            settings
          );

          var a11yStrings = buildA11yStrings(tree, [], "normal");
          return flatten(a11yStrings).join(", ");
        };

        /* harmony default export */ __webpack_exports__[
          "default"
        ] = renderA11yString;
      })();
      __webpack_exports__ = __webpack_exports__.default;
      /******/ return __webpack_exports__;
      /******/
    })();
  }
);
